In [ ]:
Problem statement¶
The attributes of this dataset are: age, gender, heart rate, systolic blood pressure, diastolic blood pressure, blood sugar, ck-mb and troponin with negative or positive output. According to the provided information, the medical dataset classifies either heart attack or none. The gender column in the data is normalized: the male is set to 1 and the female to 0. The glucose column is set to 1 if it is > 120; otherwise, 0. As for the output, positive is set to 1 and negative to 0.
The CK-MB test is a blood test that looks for a specific enzyme. That enzyme, creatine kinase-myocardial band, is most common in your heart but can also mean you have damage to other muscles in your body.
In [1]:
#loading dataset
import pandas as pd
import numpy as np
#visualisation
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
#EDA
from collections import Counter
import pandas_profiling as pp
# data preprocessing
from sklearn.preprocessing import StandardScaler
# data splitting
from sklearn.model_selection import train_test_split
# data modeling
from sklearn.metrics import confusion_matrix,accuracy_score,roc_curve,classification_report
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from xgboost import XGBClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
#ensembling
In [2]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
In [3]:
data = pd.read_csv(r"C:\MACHINE LEARNING\heart disease\Medicaldataset.csv")
In [4]:
data.head()
Out[4]:
In [5]:
data.shape
Out[5]:
In [6]:
data.info()
EDA¶
In [7]:
pp.ProfileReport(data)
Out[7]:
In [8]:
data.columns
Out[8]:
In [9]:
data.describe()
Out[9]:
In [10]:
# checking whether data contains null values
data.isnull().sum()
Out[10]:
Data pre-processing¶
In [11]:
for i in data.columns:
print({i:data[i].unique()})
#to get all unique values
In [12]:
# have converted the categorical data to numerical manually as the data containns only one object variable
#replacing values
data['Result'].replace(['negative', 'positive'],
[0, 1], inplace=True)
In [13]:
# now lets check whether it converted or not
data.dtypes
Out[13]:
Data Visualization¶
In [14]:
p = data.Gender.value_counts().plot(kind='bar')
From the above Visualization we can predict that we have greater number of MALE patients than the FEMALE patient
In [15]:
plt.hist(data['Age'])
Out[15]:
In [16]:
plt.hist(data['Heart rate'])
Out[16]:
In [17]:
plt.hist(data['Systolic blood pressure'])
Out[17]:
In [18]:
plt.hist(data['Diastolic blood pressure'])
Out[18]:
In [19]:
plt.hist(data['Blood sugar'])
Out[19]:
In [20]:
plt.hist(data['CK-MB'])
Out[20]:
In [21]:
plt.hist(data['Troponin'])
Out[21]:
In [22]:
p = data.Result.value_counts().plot(kind='bar')
In [23]:
data['Result'].value_counts()
# here we can see that the data is unevenly distributed between the two classes
# class 1 has the highest number of patients rather then the class 0
Out[23]:
The above visualization it is clearly visible that our dataset is completly imbalanced in fact the number of patients who are suffering from the Heart-attack is half of the patients who are not having Heart-attack
Checking the Correlation between all the features¶
In [24]:
plt.figure(figsize=(12,10))
p = sns.heatmap(data.corr(),annot=True,cmap='Reds')
Scaling the data¶
In [25]:
# create X & Y
X = data.values[:,0:-1]
Y = data.values[:,-1]
In [26]:
print(X.shape)
print(Y.shape)
In [27]:
# now scale the data
from sklearn.preprocessing import StandardScaler
scaler =StandardScaler()
scaler.fit(X)
X=scaler.transform(X)
#X=scaler.fit_transform(X)
print(X)
# it transforms the data into the specific scale so that it makes data points cloder to each other
Model Building¶
In [28]:
# now build the model
from sklearn.model_selection import train_test_split
#split the data into test and train
X_train, X_test, Y_train, Y_test= train_test_split(X,Y, test_size=0.3,random_state=10)
Logistic Regression¶
In [29]:
from sklearn.linear_model import LogisticRegression
#create a model
classifier=LogisticRegression()
#fitting training data to the model
classifier.fit(X_train,Y_train)
Y_pred=classifier.predict(X_test)
print(Y_pred)
In [31]:
# evaluating the model==>
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
cfm=confusion_matrix(Y_test,Y_pred)
print(cfm)
print("Classification report: ")
print(classification_report(Y_test,Y_pred))
acc=accuracy_score(Y_test, Y_pred)
print("Accuracy of the model: ",acc)
In [32]:
#since the value of f1 precision and recall are less for class 1 so tunning is required
In [33]:
# tunning model ->
In [34]:
#store the predicted probablities
y_pred_prob = classifier.predict_proba(X_test)
print(y_pred_prob)
In [35]:
y_pred_class=[]
for value in y_pred_prob[:,1]:
if value > 0.44:
y_pred_class.append(1)
else:
y_pred_class.append(0)
#print(y_pred_class)
In [36]:
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
cfm=confusion_matrix(Y_test,y_pred_class)
print(cfm)
print("Classification report: ")
print(classification_report(Y_test,y_pred_class))
acc=accuracy_score(Y_test, y_pred_class)
print("Accuracy of the model: ",acc)
#print(classification_report(Y_test, y_pred_class))
In [37]:
for a in np.arange(0.4,0.61,0.01):
predict_mine = np.where(y_pred_prob[:,1] > a, 1, 0)
cfm=confusion_matrix(Y_test, predict_mine)
total_err=cfm[0,1]+cfm[1,0]
print("Errors at threshold ", a, ":",total_err, " , type 2 error :",
cfm[1,0]," , type 1 error:", cfm[0,1])
# while finalizing a threshold focus upon reducing the total error compare to the base model
# and then finalize that thershold which give you less type 2 error
SVM¶
In [44]:
from sklearn.svm import SVC
svc_model = SVC(kernel = 'rbf',gamma=0.1,C=5)
svc_model.fit(X_train,Y_train)
Y_pred = svc_model.predict(X_test)
print(list(Y_pred))
In [45]:
svc_model.score(X_train,Y_train)
Out[45]:
In [46]:
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
cfm=confusion_matrix(Y_test,y_pred_class)
print(cfm)
print("Classification report: ")
print(classification_report(Y_test,y_pred_class))
acc=accuracy_score(Y_test, y_pred_class)
print("Accuracy of the model: ",acc)
#print(classification_report(Y_test, y_pred_class))
KNN¶
In [47]:
# predicting using the KNeighbors classifier
from sklearn.neighbors import KNeighborsClassifier
model_KNN = KNeighborsClassifier(n_neighbors = int(np.sqrt(len(X_train))),metric='euclidean')
#euclidean,manhattan,minkowski
#fit the model on the data and predict the values
model_KNN.fit(X_train,Y_train)
Y_pred = model_KNN.predict(X_test)
print(list(zip(Y_test,Y_pred)))
In [48]:
np.sqrt(len(X_train))
Out[48]:
In [49]:
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
cfm=confusion_matrix(Y_test,Y_pred)
print(cfm)
print("Classification report: ")
print(classification_report(Y_test,Y_pred))
acc=accuracy_score(Y_test, Y_pred)
print("Accuracy of the model: ",acc)
In [51]:
from sklearn.metrics import accuracy_score
my_dict={}
for K in range(1,100):
model_KNN = KNeighborsClassifier(n_neighbors=K,metric="euclidean")
model_KNN.fit(X_train, Y_train)
Y_pred = model_KNN.predict(X_test)
print ("Accuracy is ", accuracy_score(Y_test,Y_pred), "for K-Value:",K)
my_dict[K]=accuracy_score(Y_test,Y_pred)
In [52]:
my_dict
Out[52]:
In [53]:
for k in my_dict:
if my_dict[k]==max(my_dict.values()):
print(k,':',my_dict[k])
In [55]:
# predicting using the KNeighbors classifier
from sklearn.neighbors import KNeighborsClassifier
model_KNN = KNeighborsClassifier(n_neighbors = 53,metric='euclidean')
#euclidean,manhattan,minkowski
#fit the model on the data and predict the values
model_KNN.fit(X_train,Y_train)
Y_pred = model_KNN.predict(X_test)
print(list(zip(Y_test,Y_pred)))
In [56]:
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
cfm=confusion_matrix(Y_test,Y_pred)
print(cfm)
print("Classification report: ")
print(classification_report(Y_test,Y_pred))
acc=accuracy_score(Y_test, Y_pred)
print("Accuracy of the model: ",acc)
Decision Tree Classifier¶
In [67]:
# predicting using the decision tree classifier
from sklearn.tree import DecisionTreeClassifier
model_DecisionTree = DecisionTreeClassifier(criterion ='gini',random_state=10)
#fit the model on the data nad predict thee values
model_DecisionTree.fit(X_train,Y_train)
Y_pred = model_DecisionTree.predict(X_test)
#print(Y_pred)
#print(list(zip(Y_test)))
In [68]:
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
cfm=confusion_matrix(Y_test,Y_pred)
print(cfm)
print("Classification report: ")
print(classification_report(Y_test,Y_pred))
acc=accuracy_score(Y_test, Y_pred)
print("Accuracy of the model: ",acc)
XG Boost Classifier¶
In [71]:
from xgboost import XGBClassifier
model_GradientBoosting = XGBClassifier (n_estimators=100,
random_state=10)
#fit the model on the data and predict the values
model_GradientBoosting.fit(X_train,Y_train)
Y_pred =model_GradientBoosting.predict(X_test)
In [72]:
from sklearn.metrics import confusion_matrix, accuracy_score,classification_report
#confusion matrix
print(confusion_matrix(Y_test,Y_pred))
print(classification_report(Y_test,Y_pred))
print(accuracy_score(Y_test,Y_pred))
Random Forest Classifier¶
In [73]:
from sklearn.ensemble import RandomForestClassifier
model_RandomForest= RandomForestClassifier(n_estimators=100,random_state=10)
# fit the model on the data and predict the values
model_RandomForest.fit(X_train,Y_train)
Y_pred=model_RandomForest.predict(X_test)
In [74]:
from sklearn.metrics import confusion_matrix, accuracy_score,classification_report
#confusion matrix
print(confusion_matrix(Y_test,Y_pred))
print(classification_report(Y_test,Y_pred))
print(accuracy_score(Y_test,Y_pred))
In [75]:
model_RandomForest.score(X_train,Y_train)
Out[75]:
The Conclusion from Model-building¶
Accuracy_score gained by all the algorithms while building model
Logistic Regression - 0.81313
SVM - 0.79040
KNN - 0.68181
Decision Tree - 0.0.98737
Random Forest - 0.99242
After using all these records,we are able to build machine learninng model(Random forest is the best model with accuracy score - 0.99242) to predict wheather patient is suffering from Heart-Diesease or not
In [77]:
model_RandomForest.feature_importances_
Out[77]:
From the above output, It is not much clear that which feature is important for that reason .we will now make a visualization of the same.
Plotting feature importances¶
In [78]:
sample = pd.DataFrame()
sample ['Columns'] = data.columns[0:-1]
sample ['Results'] = model_RandomForest.feature_importances_
sample.sort_values('Results',ascending=False)
Out[78]:
In [80]:
print(sample)
In [81]:
df = pd.DataFrame(sample)
plot = df.plot.bar(x='Columns',y='Results',)
Troponin is a type of protein found in the muscles of your heart. Troponin isn't normally found in the blood. When heart muscles become damaged, troponin is sent into the bloodstream. As heart damage increases, greater amounts of troponin are released in the blood.
Here fron the above visualization ,it is clearly visible that TROPONIN is the feature_importance in the dataset
Saving Model - RandomForest¶
In [82]:
import pickle
In [83]:
# firstly dump the model with pickle
pickle.dump(model_RandomForest,open("Heart_model1.pkl",'wb'))
In [84]:
# load the saved model
loaded_model = pickle.load(open("Heart_model1.pkl", "rb"))
Predicting by taking input from user¶
In [100]:
input_data1 = (21,1,94,98,46,296,6.75,1.06)
input_data_as_numpy_array1 = np.asarray(input_data1)
input_reshape1 = input_data_as_numpy_array1.reshape(1,-1)
In [101]:
prediction1 = loaded_model.predict(input_reshape1)
print(prediction1)
In [102]:
if (prediction1[0]==0):
print("The person does not has Heart ")
else:
print("The person has Heart")
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [ ]:
In [14]:
!pip install gradio
In [15]:
import gradio as gr
In [13]:
import fsspec
pip install fsspec
In [1]:
def inference(age, sex, ch, cardio):
s = 0 if sex=='female' else 1
df = pd.DataFrame([[age, s, ch, cardio]],
columns=['Age', 'Sex', 'Cholestoral (in mg/dl)',
'Resting electrocardiographic results'])
df = st.transform(df)
pred = trainedmodel.predict_proba(df)[0]
res = {'No Heart Desease': pred[0], 'Has Heart Desease': pred[1]}
return res
sex = gr.Radio(['female', 'male'], label="Sex")
age = gr.Slider(minimum=1, maximum=100, value=22, label="Age")
ch = gr.Slider(minimum=120, maximum=560, value=200, label="Cholestoral (in mg/dl)")
cardio = gr.Radio([0, 1, 2], label="Resting electrocardiographic results")
gr.Interface(inference, [age, sex, ch, cardio], "label", live=True).launch(share=True) #, debug=True Use in Colab
In [ ]: